The invention relates to Field Programmable Gate Arrays (FPGAs). More particularly, the invention relates to methods for constraining circuit element positions in structured FPGA layouts.
Programmable ICs are a well-known type of digital integrated circuit that may be programmed by a user to perform specified logic functions. One type of programmable IC, the field programmable gate array (FPGA), typically includes an array of configurable logic blocks (CLBs) surrounded by a ring of programmable input/output blocks (IOBs). The CLBs and IOBs are interconnected by a programmable interconnect structure. The CLBs, IOBs, and interconnect structure are typically programmed by loading a stream of configuration data (bitstream) into internal configuration memory cells that define how the CLBs, IOBs, and interconnect structure are configured. The configuration data may be read from memory (e.g., an external PROM) or written into the FPGA by an external device. The collective states of the individual memory cells then determine the function of the FPGA.
One type of FPGA, the Xilinx XC4000(trademark) Series FPGA, is described in detail in pages 4-5 through 4-69 of the Xilinx 1998 Data Book entitled xe2x80x9cThe Programmable Logic Data Book 1998xe2x80x9d, published in 1998 and available from Xilinx, Inc., 2100 Logic Drive, San Jose, Calif. 95124, which pages are incorporated herein by reference. (Xilinx, Inc., owner of the copyright, has no objection to copying these and other pages referenced herein but otherwise reserves all copyright rights whatsoever.)
FIG. 1A shows a simplified diagram of an XC4000-Series FPGA 100. The FPGA includes a uniform array of CLBs surrounded by a ring of IOBs, as described above. (The exemplary arrays herein are generally shown smaller than actual logic arrays in order to facilitate clear and simple drawings, but actual logic arrays typically include many more rows and columns of elements.) The CLB array typically includes variations in routing, for example at the outer edges and/or the center of the array, but the CLB array is considered uniform for purposes of this discussion because all of the logic blocks are similar. Each CLB includes two 4-input function generators, one 3-input function generator, and two flip-flops, in addition to other logic.
A more advanced FPGA is the Xilinx Virtex(copyright) FPGA, which in addition to the CLBs includes blocks of Random Access Memory (RAM). The Xilinx Virtex-II FPGA is described in detail in pages 3-75 through 3-96 of the Xilinx 2000 Data Book entitled xe2x80x9cThe Programmable Logic Data Book 2000xe2x80x9d, published Apr., 2000, available from Xilinx, Inc., 2100 Logic Drive, San Jose, Calif. 95124, which pages are incorporated herein by reference.
FIG. 1B shows a simplified diagram of a Virtex FPGA 110. The FPGA includes a uniform array of CLBs, flanked by two columns of RAM blocks, with a ring of IOBs around the CLBs and RAM blocks. The Virtex CLB is organized into two functionally similar blocks called xe2x80x9cslicesxe2x80x9d, each of which includes two 4-input function generators and two flip-flops, in addition to other logic. The RAM blocks, of course, include different elements and are larger than the CLBs.
An even more advanced FPGA is the Xilinx Virtex(copyright)-II FPGA, which in addition to the CLBs includes blocks of Random Access Memory (RAM) and blocks implementing multiplier functions. (The Xilinx Virtex-II FPGA is described in detail in pages 33-75 of the xe2x80x9cVirtex-II Platform FPGA Handbookxe2x80x9d, published January, 2001, available from Xilinx, Inc., 2100 Logic Drive, San Jose, Calif. 95124, which pages are incorporated herein by reference.) The RAM and multiplier blocks are interspersed within the CLB array, forming a non-uniform array of logic blocks, as shown in FIG. 1C.
FIG. 1C shows a simplified diagram of a Virtex-II FPGA 120. The FPGA includes an array of CLBs, with columns of RAM blocks and multiplier blocks inserted within the CLB array. The resulting logic array is therefore non-uniform in nature, including three different kinds of logic blocks. The logic array is surrounded by a ring of IOBs, the IOB ring also including Digital Clock Manager (DCM) logic blocks. The Virtex-II FPGA also includes other types of logic blocks, but these are omitted from FIG. 1C for the sake of clarity. The Virtex-II CLB is organized into four slices, each of which includes two 4-input function generators and two flip-flops, in addition to other logic. Each CLB also includes two tristate buffers. The RAM blocks and multiplier blocks include different elements from the CLBs. The RAM and multiplier blocks are designed such that the height of each block is a multiple of the CLB height.
As FPGA designs increase in complexity, they reach a point at which the designer cannot deal with the entire design at the gate level. Where once a typical FPGA design comprised perhaps 5,000 gates, FPGA designs with over 100,000 gates are now common. To deal with this complexity, circuits are typically partitioned into smaller circuits that are more easily handled. Often, these smaller circuits are divided into yet smaller circuits, imposing on the design a multi-level hierarchy of logical blocks.
Libraries of predeveloped blocks of logic have been developed that can be included in an FPGA design. Such library modules include, for example, adders, multipliers, filters, and other arithmetic and DSP functions from which complex designs can be readily constructed. The use of predeveloped logic blocks permits faster design cycles, by eliminating the redesign of duplicated circuits. Further, such blocks are typically well tested, thereby making it easier to develop a reliable complex design.
To offer the best possible performance, some library modules have a fixed size and shape, with relative location restrictions on each element. One type of module having a fixed size and shape is the Relationally Placed Macro (RPM) from Xilinx, Inc. RPMs are described in pages 4-96 and 4-97 of the xe2x80x9cLibraries Guidexe2x80x9d (hereinafter referred to as the xe2x80x9cXilinx Libraries Guidexe2x80x9d), published October 1995 and available from Xilinx, Inc., which pages are incorporated herein by reference. An RPM is a schematic that includes constraints defining the order and structure of the underlying circuits. The location of each element within the RPM is defined relative to other elements in the RPM, regardless of the eventual placement of the RPM in the overall design. For example, an RPM might contain 8 flip-flops constrained to be placed into four XC4000 CLBs in a vertical column. The column of four CLBs can then be placed anywhere in any XC4000 Series FPGA.
Relative CLB locations in an RPM are specified using a Relative Location Constraint called xe2x80x9cRLOCxe2x80x9d. RLOC constraints are described in detail in pages 4-71 through 4-95 of the Xilinx Libraries Guide, which pages are incorporated herein by reference. FIG. 2A shows how RLOC constraints are related to physical location in an array of XC4000 Series logic blocks, and how they are associated with assigned coordinates. Elements having an RLOC value of R0C0 are located in a given CLB corresponding to the (0,0) coordinate location. The next CLB xe2x80x9cbelowxe2x80x9d the (0,0) CLB is designated as R1C0, corresponding to the (0,1) coordinate location. When the FPGA design is mapped and placed by the FPGA implementation tools (prior to the final routing step), these RLOC constraints are referenced and, in effect, make the RPM a xe2x80x9cjigsaw puzzle piecexe2x80x9d to be fitted into the FPGA along with other elements and/or modules. Although the RPM has a rigid size and shape, other logic can be placed within the borders of the RPM.
Logic can also be mapped to elements within the logic block. For example, the function generators and flip-flops inside a CLB can be directly addressed using RLOC constraints. For example, in an XC4000 Series FPGA, the xe2x80x9cFxe2x80x9d function generator within the (0,0) CLB is addressed by assigning the constraint xe2x80x9cRLOC=R0C0.Fxe2x80x9d to the logic element assigned to that location. The xe2x80x9cYxe2x80x9d flip-flop in the same CLB is addressed by assigning the constraint xe2x80x9cRLOC=R0C0.FFYxe2x80x9d, and so forth.
The exact numbers assigned using RLOC constraints are unimportant in an FPGA with a uniform array of logic blocks. Only the relative values of the RLOC constraints are important. For example, if a user generates an RPM using two vertically adjacent CLBs at a first location, and then generates an identical RPM using two vertically adjacent CLBs at a second location, the resulting RPMs will be exactly the same, due to a process called xe2x80x9cnormalizationxe2x80x9d. Normalization is the process whereby the RPM creation software (provided by the FPGA manufacturer) scans the selected logic blocks, looking for the RLOC with the lowest row and column number. The RPM creation software then subtracts the lowest row and column numbers from each RLOC, resulting in an RPM where the upper left corner has assigned relative location RLOC=R0C0. Normalization allows a user to create an RPM from any logic implemented anywhere in a logic array. An example of normalization is now described using the CLB array shown in FIG. 2A.
FIG. 2A shows a uniform CLB array 200, such as those in an XC4000 Series FPGA. A first circuit is implemented using two CLBs at coordinates (0,0) and (0,1), forming area 201. A second, identical circuit is implemented using two CLBs at coordinates (2,2) and (2,3), forming area 202. When the second circuit is selected and the RPM creation software is invoked, the software scans the selected logic blocks and determines that the lowest R,C coordinates are (2,2). The value of 2 is then subtracted from each column number and each row number of the selected logic blocks. The resulting RPM thus includes CLBs with relative locations (0,0) and (0,1), exactly as does the RPM resulting from the first circuit.
Although this method of specifying relative locations is a useful way to represent positions in a uniform array, when the array of logic blocks is non-uniform the representation is less straight-forward. In a non-uniform array where all logic blocks are the same size regardless of their differing functions, the above-described scheme still works as desired, provided the placement software knows what logic elements can be placed in which locations. However, in a non-uniform scheme including blocks of different sizes, locations must be specified in some other manner. For the Virtex FPGA, the locations of CLBs are specified using a first numerical coordinate scheme, while RAM blocks are specified using a second numerical coordinate scheme independent from the first one, as shown in FIG. 2B.
FIG. 2B shows an array 210 of logic blocks in a Virtex FPGA. A centrally-located array of CLBs has assigned locations the same as those shown in FIG. 2A. The flanking columns of RAM blocks have locations specified independently from those of the CLB array, but in a similar manner. (The numbers and relative sizes of CLBs and RAM blocks in the figures herein are not representative of actual Virtex and Virtex-II FPGAs.)
In the logic array of FIG. 2B, an RPM implemented using only CLBs can be defined in the same manner as the example in FIG. 2A, at any point in the array, and is normalized by the RPM creation software. An RPM including only RAM blocks can be defined similarly, and normalization operates correctly. However, an RPM including both types of logic blocks does not normalize correctly. Referring to FIG. 2B, an RPM created in area 212 of array 210 would ideally result in the same RPM as if it were created in area 211. However, this is not the case, as shown by the following example.
A first circuit is implemented in area 211 of array 210, using one RAM block at coordinates (0,0) and two CLBs at coordinates (0,0) and (0,1). When converted to an RPM, this first RPM has the same shape as area 211. A second, identical circuit is implemented in area 212, using one RAM block at coordinates (0,1) and two CLBs at coordinates (0,2) and (0,3). When the second circuit is selected and the RPM creation software is invoked, the software scans the selected logic blocks and determines that the lowest R,C coordinates are (0,1). The value of 1 is then subtracted from each row number of the selected logic blocks, while the column numbers remain unchanged. The resulting RPM thus includes one RAM block with relative coordinates (0,0) and two CLBs with relative locations (0,1) and (0,2). While logically correct, this second RPM does not have the shape of the original area 212. Instead, it includes, for example, the logic blocks in area 213. Therefore, creating RPMs including logic blocks of more than one type is a problematic process.
This difficulty is augmented in the Virtex-II FPGA, which has three types of logic blocks in the logic array. Using the previously-described method of designating relative locations, each type of logic block would have a separate coordinate system, as shown in FIG. 2C. The situation is further complicated if the logic array is defined to include the ring of IOBs shown in FIG. 1C, which also includes the Digital Clock Manager (DCM) blocks and other types of blocks not shown in FIG. 1C.
An RPM can be moved from place to place in a non-uniform logic array, provided that the new location includes the correct type of logic block in the correct positions for the RPM logic. However, the processes of defining and modifying an RPM in a non-uniform logic array are subject to the limitations described above. It is therefore desirable to provide methods for specifying circuit element positions in a uniform manner that can be applied to any logic block in a non-uniform logic array.
The invention provides methods and software for designating circuit element positions using uniform coordinate systems that can be applied to non-uniform logic arrays. A xe2x80x9csite mapxe2x80x9d is constructed comprising a uniform array of xe2x80x9csitesxe2x80x9d. A uniform coordinate system is then applied to the site map. The various logic blocksxe2x80x94for example, the slices, tristate buffers, RAM blocks, and multiplier blocks of the Xilinx Virtex-II FPGAxe2x80x94are mapped to the site array. The result is the imposition of a uniform coordinate system on a non-uniform logic array, using the intervening abstraction of a site array. The logic blocks in the logic array may be of different types and sizes.
Because the site array is uniform, a relative location constraint applied to a site within the site array retains its validity regardless of the location of the site within the site array, even when the relative location constraints are normalized. However, during the subsequent placement operation the implementation software must take into account which sites support which logic blocks, so that logic blocks are only mapped to sites that support the implemented functions.